layout->addWidget(iconLabel);
layout->addWidget(textLabel);
- for (QToolButton *button : qAsConst(buttons)) {
+ for (QToolButton *button : std::as_const(buttons)) {
layout->addWidget(button);
}
}
if (account->trustCertificates()) {
- for (const auto &error : qAsConst(errors)) {
+ for (const auto &error : std::as_const(errors)) {
certs->append(error.certificate());
}
return true;
bool allTrusted = true;
- for (const auto &error : qAsConst(errors)) {
+ for (const auto &error : std::as_const(errors)) {
if (!account->approvedCerts().contains(error.certificate())) {
allTrusted = false;
}
{
const auto settings = ConfigFile::settingsWithGroup(QLatin1String(accountsC));
settings->setValue(QLatin1String(versionC), maxAccountsVersion);
- for (const auto &acc : qAsConst(_accounts)) {
+ for (const auto &acc : std::as_const(_accounts)) {
settings->beginGroup(acc->account()->id());
saveAccountHelper(acc->account().data(), *settings, saveCredentials);
settings->endGroup();
settings->endGroup();
// Wipe confusing keys from the future, ignore the others
- for (const auto &badKey : qAsConst(deleteKeys)) {
+ for (const auto &badKey : std::as_const(deleteKeys)) {
settings->remove(badKey);
}
}
void EditLocallyJob::disconnectFolderSignals()
{
- for (const auto &connection : qAsConst(_folderConnections)) {
+ for (const auto &connection : std::as_const(_folderConnections)) {
disconnect(connection);
}
}
auto linkSharePresent = false;
auto placeholderLinkSharePresent = false;
- for (const auto &share : qAsConst(_shares)) {
+ for (const auto &share : std::as_const(_shares)) {
const auto shareType = share->getShareType();
if (!linkSharePresent && shareType == Share::TypeLink) {
auto linkSharePresent = false;
auto secureFileDropLinkSharePresent = false;
- for (const auto &share : qAsConst(_shares)) {
+ for (const auto &share : std::as_const(_shares)) {
const auto shareType = share->getShareType();
if (!linkSharePresent && shareType == Share::TypeLink) {
const auto existingBlacklistSet = QSet<QString>{existingBlacklist.begin(), existingBlacklist.end()};
auto expandedBlacklistSet = QSet<QString>{existingBlacklist.begin(), existingBlacklist.end()};
- for (const auto &path : qAsConst(e2eFoldersToBlacklist)) {
+ for (const auto &path : std::as_const(e2eFoldersToBlacklist)) {
expandedBlacklistSet.insert(path);
}
emit folderListChanged(_folderMap);
- for (const auto folder : qAsConst(_folderMap)) {
+ for (const auto folder : std::as_const(_folderMap)) {
folder->processSwitchedToVirtualFiles();
}
{
if (_currentEtagJob.isNull()) {
Folder *folder = nullptr;
- for (Folder *f : qAsConst(_folderMap)) {
+ for (Folder *f : std::as_const(_folderMap)) {
if (f->etagJob()) {
// Caveat: always grabs the first folder with a job, but we think this is Ok for now and avoids us having a separate queue.
_currentEtagJob = f->etagJob();
void FolderMan::slotStartScheduledFolderSync()
{
if (isAnySyncRunning()) {
- for (auto f : qAsConst(_folderMap)) {
+ for (auto f : std::as_const(_folderMap)) {
if (f->isSyncRunning())
qCInfo(lcFolderMan) << "Currently folder " << f->remoteUrl().toString() << " is running, wait for finish!";
}
void FolderMan::slotAccountRemoved(AccountState *accountState)
{
QVector<Folder *> foldersToRemove;
- for (const auto &folder : qAsConst(_folderMap)) {
+ for (const auto &folder : std::as_const(_folderMap)) {
if (folder->accountState() == accountState) {
foldersToRemove.push_back(folder);
}
}
- for (const auto &folder : qAsConst(foldersToRemove)) {
+ for (const auto &folder : std::as_const(foldersToRemove)) {
removeFolder(folder);
}
}
}
}
- for (const auto &f : qAsConst(foldersToRemove)) {
+ for (const auto &f : std::as_const(foldersToRemove)) {
removeFolder(f);
}
emit folderListChanged(_folderMap);
qCWarning(lcFolderMan) << "The server version is unsupported:" << account->serverVersion()
<< "pausing all folders on the account";
- for (auto &f : qAsConst(_folderMap)) {
+ for (auto &f : std::as_const(_folderMap)) {
if (f->accountState()->account().data() == account) {
f->setSyncPaused(true);
}
void FolderMan::slotScheduleFolderByTime()
{
- for (const auto &f : qAsConst(_folderMap)) {
+ for (const auto &f : std::as_const(_folderMap)) {
// Never schedule if syncing is disabled or when we're currently
// querying the server for etags
if (!f->canSync() || f->etagJob()) {
}
bool success = false;
- for (const auto &f : qAsConst(foldersToRemove)) {
+ for (const auto &f : std::as_const(foldersToRemove)) {
if (!f) {
qCCritical(lcFolderMan) << "Can not remove null folder";
return;
auto runSeen = false;
auto various = false;
- for (const Folder *folder : qAsConst(folders)) {
+ for (const Folder *folder : std::as_const(folders)) {
// We've already seen an error, worst case met.
// No need to check the remaining folders.
if (errorsSeen) {
{
// Note that the setting will revert to 'true' if all folders
// are deleted...
- for (Folder *folder : qAsConst(_folderMap)) {
+ for (Folder *folder : std::as_const(_folderMap)) {
folder->setIgnoreHiddenFiles(ignore);
folder->saveToSettings();
}
{
qCInfo(lcFolderMan) << "Got files push notification for account" << account;
- for (auto folder : qAsConst(_folderMap)) {
+ for (auto folder : std::as_const(_folderMap)) {
// Just run on the folders that belong to this account
if (folder->accountState()->account() != account) {
continue;
endInsertRows();
}
- for (const auto undecidedIndex : qAsConst(undecidedIndexes)) {
+ for (const auto undecidedIndex : std::as_const(undecidedIndexes)) {
emit suggestExpand(index(undecidedIndex, 0, parentIdx));
}
/* Try to remove from the undecided lists the items that are not on the server. */
void FolderStatusModel::slotApplySelectiveSync()
{
- for (const auto &folderInfo : qAsConst(_folders)) {
+ for (const auto &folderInfo : std::as_const(_folders)) {
if (!folderInfo._fetched) {
folderInfo._folder->journalDb()->setSelectiveSyncList(SyncJournalDb::SelectiveSyncUndecidedList, QStringList());
continue;
_showInExplorerNavigationPane = show;
// Re-generate a new CLSID when enabling, possibly throwing away the old one.
// updateCloudStorageRegistry will take care of removing any unknown CLSID our application owns from the registry.
- for (const auto &folder : qAsConst(_folderMan->map())) {
+ for (const auto &folder : std::as_const(_folderMan->map())) {
folder->setNavigationPaneClsid(show ? QUuid::createUuid() : QUuid());
}
// Then re-save every folder that has a valid navigationPaneClsid to the registry.
// We currently don't distinguish between new and existing CLSIDs, if it's there we just
// save over it. We at least need to update the tile in case we are suddently using multiple accounts.
- for (const auto &folder : qAsConst(_folderMan->map())) {
+ for (const auto &folder : std::as_const(_folderMan->map())) {
if (!folder->navigationPaneClsid().isNull()) {
// If it already exists, unmark it for removal, this is a valid sync root.
entriesToRemove.removeOne(folder->navigationPaneClsid());
}
// Then remove anything that isn't in our folder list anymore.
- for (const auto &clsid : qAsConst(entriesToRemove)) {
+ for (const auto &clsid : std::as_const(entriesToRemove)) {
const auto clsidStr = clsid.toString();
const QString clsidPath = QString() % R"(Software\Classes\CLSID\)" % clsidStr;
const QString clsidPathWow64 = QString() % R"(Software\Classes\Wow6432Node\CLSID\)" % clsidStr;
#else
QStringList messages;
messages.append(tr("Disconnected from accounts:"));
- for (const auto &accountState : qAsConst(problemAccounts)) {
+ for (const auto &accountState : std::as_const(problemAccounts)) {
QString message = tr("Account %1: %2").arg(accountState->account()->displayName(), accountState->stateString(accountState->state()));
if (!accountState->connectionErrors().empty()) {
message += QLatin1String("\n");
Folder *f = FolderMan::instance()->folder(alias);
if (f) {
const QString message = buildRegisterPathMessage(removeTrailingSlash(f->path()));
- for (const auto &listener : qAsConst(_listeners)) {
+ for (const auto &listener : std::as_const(_listeners)) {
qCInfo(lcSocketApi) << "Trying to send SocketAPI Register Path Message -->" << message << "to" << listener->socket;
listener->sendMessage(message);
}
void SocketApi::broadcastMessage(const QString &msg, bool doWait)
{
- for (const auto &listener : qAsConst(_listeners)) {
+ for (const auto &listener : std::as_const(_listeners)) {
listener->sendMessage(msg, doWait);
}
}
QString msg = buildMessage(QLatin1String("STATUS"), systemPath, fileStatus.toSocketAPIString());
Q_ASSERT(!systemPath.endsWith('/'));
uint directoryHash = qHash(systemPath.left(systemPath.lastIndexOf('/')));
- for (const auto &listener : qAsConst(_listeners)) {
+ for (const auto &listener : std::as_const(_listeners)) {
listener->sendMessageIfDirectoryMonitored(msg, directoryHash);
}
}
void SyncConflictsModel::applySolution()
{
- for(const auto &syncConflict : qAsConst(_conflictData)) {
+ for(const auto &syncConflict : std::as_const(_conflictData)) {
if (syncConflict.isValid()) {
qCInfo(lcSyncConflictsModel) << syncConflict.mExistingFilePath << syncConflict.mConflictingFilePath << syncConflict.solution();
ConflictSolver solver;
_conflictData.clear();
_conflictData.reserve(_data.size());
- for (const auto &oneConflict : qAsConst(_data)) {
+ for (const auto &oneConflict : std::as_const(_data)) {
const auto folder = FolderMan::instance()->folder(oneConflict._folder);
if (!folder) {
qCWarning(lcSyncConflictsModel) << "no Folder instance for" << oneConflict._folder;
endResetModel();
}
- for (const auto &provider : qAsConst(_providers)) {
+ for (const auto &provider : std::as_const(_providers)) {
startSearchForProvider(provider._id);
}
}
void UnifiedSearchResultsListModel::disconnectAndClearSearchJobs()
{
- for (const auto &connection : qAsConst(_searchJobConnections)) {
+ for (const auto &connection : std::as_const(_searchJobConnections)) {
if (connection) {
QObject::disconnect(connection);
}
return;
}
- for (const auto &activity : qAsConst(toNotifyList)) {
+ for (const auto &activity : std::as_const(toNotifyList)) {
if (activity._objectType == QStringLiteral("chat")) {
showDesktopTalkNotification(activity);
} else {
void UserModel::addUser(AccountStatePtr &user, const bool &isCurrent)
{
bool containsUser = false;
- for (const auto &u : qAsConst(_users)) {
+ for (const auto &u : std::as_const(_users)) {
if (u->account() == user->account()) {
containsUser = true;
continue;
const auto isCurrentUserChanged = !_users[id]->isCurrentUser();
if (isCurrentUserChanged) {
- for (const auto user : qAsConst(_users)) {
+ for (const auto user : std::as_const(_users)) {
user->setCurrentUser(false);
}
_users[id]->setCurrentUser(true);
bool ProcessDirectoryJob::isAnyParentBeingRestored(const QString &file) const
{
- for (const auto &directoryNameToRestore : qAsConst(_discoveryData->_directoryNamesToRestoreOnPropagation)) {
+ for (const auto &directoryNameToRestore : std::as_const(_discoveryData->_directoryNamesToRestoreOnPropagation)) {
if (file.startsWith(QString(directoryNameToRestore + QLatin1Char('/')))) {
qCWarning(lcDisco) << "File" << file << " is within the tree that's being restored" << directoryNameToRestore;
return true;
}
// Ask all the running composite jobs if they have something new to schedule.
- for (auto runningJob : qAsConst(_runningJobs)) {
+ for (auto runningJob : std::as_const(_runningJobs)) {
ASSERT(runningJob->_state == Running);
if (possiblyRunNextJob(runningJob)) {
// Make sure that if there is a "hole" and then a few more chunks, on the server
// we should remove the later chunks. Otherwise when we do dynamic chunk sizing, we may end up
// with corruptions if there are too many chunks, or if we abort and there are still stale chunks.
- for (const auto &serverChunk : qAsConst(_serverChunks)) {
+ for (const auto &serverChunk : std::as_const(_serverChunks)) {
auto job = new DeleteJob(propagator()->account(), Utility::concatUrlPath(chunkUploadFolderUrl(), serverChunk.originalName), this);
QObject::connect(job, &DeleteJob::finishedSignal, this, &PropagateUploadFileNG::slotDeleteJobFinished);
_jobs.append(job);
//
// This happens when the conflicts table is new or when conflict files
// are downloaded but the server doesn't send conflict headers.
- for (const auto &path : qAsConst(_seenConflictFiles)) {
+ for (const auto &path : std::as_const(_seenConflictFiles)) {
ASSERT(Utility::isConflictFile(path));
auto bapath = path.toUtf8();
upload the client file. But we still downloaded the old file in a conflict file just in case
*/
- for (const auto &syncItem : qAsConst(syncItems)) {
+ for (const auto &syncItem : std::as_const(syncItems)) {
if (syncItem->_direction != SyncFileItem::Down || syncItem->_isSelectiveSync) {
continue;
}
}
if (_discoveryPhase && _discoveryPhase->_hasDownloadRemovedItems && _discoveryPhase->_hasUploadErrorItems) {
- for (const auto &item : qAsConst(_syncItems)) {
+ for (const auto &item : std::as_const(_syncItems)) {
if (item->_instruction == CSYNC_INSTRUCTION_ERROR && item->_direction == SyncFileItem::Up) {
// item->_instruction = CSYNC_INSTRUCTION_IGNORE;
}
const auto allFilesDeleted = !_hasNoneFiles && _hasRemoveFile;
auto deletionCounter = 0;
- for (const auto &oneItem : qAsConst(_syncItems)) {
+ for (const auto &oneItem : std::as_const(_syncItems)) {
if (oneItem->_instruction == CSYNC_INSTRUCTION_REMOVE) {
if (oneItem->isDirectory()) {
const auto result = _journal->listFilesInPath(oneItem->_file.toUtf8(), [&deletionCounter] (const auto &oneRecord) {
if ((allFilesDeleted || filesDeletedThresholdExceeded) && displayDialog) {
qCWarning(lcEngine) << "Many files are going to be deleted, asking the user";
int side = 0; // > 0 means more deleted on the server. < 0 means more deleted on the client
- for (const auto &it : qAsConst(_syncItems)) {
+ for (const auto &it : std::as_const(_syncItems)) {
if (it->_instruction == CSYNC_INSTRUCTION_REMOVE) {
side += it->_direction == SyncFileItem::Down ? 1 : -1;
}
newTimer->callOnTimeout(this, [this, newTimer] {
qCInfo(lcEngine) << "Rescanning now that delayed sync run is scheduled for:" << newTimer->files;
- for (const auto &file : qAsConst(newTimer->files)) {
+ for (const auto &file : std::as_const(newTimer->files)) {
this->_filesScheduledForLaterSync.remove(file);
}
return;
}
- for (const auto &file : qAsConst(_discoveryPhase->_filesUnscheduleSync)) {
+ for (const auto &file : std::as_const(_discoveryPhase->_filesUnscheduleSync)) {
const auto fileSyncRunTimer = _filesScheduledForLaterSync.value(file);
if (fileSyncRunTimer) {
// Swap into a copy since fileStatus() reads _dirtyPaths to determine the status
QSet<QString> oldDirtyPaths;
std::swap(_dirtyPaths, oldDirtyPaths);
- for (const auto &oldDirtyPath : qAsConst(oldDirtyPaths))
+ for (const auto &oldDirtyPath : std::as_const(oldDirtyPaths))
emit fileStatusChanged(getSystemDestination(oldDirtyPath), fileStatus(oldDirtyPath));
// Make sure to push any status that might have been resolved indirectly since the last sync